home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / kernel / fs / fs.h < prev    next >
Encoding:
C/C++ Source or Header  |  1992-12-19  |  23.9 KB  |  585 lines
  1. /*
  2.  * fs.h --
  3.  *
  4.  *    The external interface to the filesystem module is defined here.
  5.  *    The main object at the interface level is Fs_Stream.  A standard set
  6.  *    of operations apply to all streams.  A stream is created by
  7.  *    Fs_Open on a pathname, with flags used to differentiate between
  8.  *    the different kinds of streams.  After that, the main operations
  9.  *    are Fs_Read, Fs_Write, Fs_IOControl, Fs_Select, and Fs_Close.
  10.  *
  11.  *    Parts of the Fs to Dev interface are also described here, including
  12.  *    Fs_Device, which describes a device, and Fs_IOParam, Fs_IOCParam,
  13.  *    and Fs_IOReply, which are standard parameter blocks.
  14.  *
  15.  * Copyright (C) 1987 Regents of the University of California
  16.  * All rights reserved.
  17.  * Permission to use, copy, modify, and distribute this
  18.  * software and its documentation for any purpose and without
  19.  * fee is hereby granted, provided that the above copyright
  20.  * notice appear in all copies.  The University of California
  21.  * makes no representations about the suitability of this
  22.  * software for any purpose.  It is provided "as is" without
  23.  * express or implied warranty.
  24.  *
  25.  *
  26.  * $Header: /cdrom/src/kernel/Cvsroot/kernel/fs/fs.h,v 9.19 91/10/01 00:46:30 mgbaker Exp $ SPRITE (Berkeley)
  27.  */
  28.  
  29. #ifndef _FS
  30. #define _FS
  31.  
  32. #ifdef KERNEL
  33. #include <sys.h>
  34. #include <syncTypes.h>
  35. #include <procTypes.h>
  36. #include <user/fs.h>
  37. #include <fmt.h>
  38. #include <bstring.h>
  39. #else
  40. #include <kernel/sys.h>
  41. #include <kernel/syncTypes.h>
  42. #include <kernel/procTypes.h>
  43. #include <fs.h>
  44. #include <fmt.h>
  45. #endif
  46.  
  47. /*
  48.  * Fragment stuff that is dependent on the filesystem block size
  49.  * defined in user/fs.h.  Actually, the fragmenting code is specific
  50.  * to a 4K block size and a 1K fragment size.
  51.  */
  52.  
  53. #define    FS_BLOCK_OFFSET_MASK    (FS_BLOCK_SIZE - 1)
  54. #define    FS_FRAGMENT_SIZE    1024
  55. #define    FS_FRAGMENTS_PER_BLOCK    4
  56.  
  57.  
  58. /*
  59.  * The following structure is referenced by the process table entry for
  60.  * a process.  It contains all the filesystem related state for the process.
  61.  */
  62. typedef struct Fs_ProcessState {
  63.     struct Fs_Stream    *cwdPtr;    /* The current working directory. */
  64.     unsigned int       filePermissions;/* The bits in this mask correspond
  65.                      * to the permissions mask of a file.
  66.                      * If one of these bits is set it
  67.                      * TURNS OFF the corresponding
  68.                      * permission when a file is created. */
  69.     int               numStreams;    /* Size of streamList array. */
  70.     struct Fs_Stream   **streamList;    /* Array of pointers to open files.
  71.                      * This list is indexed by an integer
  72.                      * known as a streamID. */
  73.     char        *streamFlags;    /* Array of flags, one for element
  74.                      * for each open stream.  Used to
  75.                      * keep the close-on-exec property */
  76.     int            numGroupIDs;    /* The length of the groupIDs array */
  77.     int            *groupIDs;    /* An array of group IDs.  Group IDs
  78.                      * are used similarly to the User ID. */
  79. } Fs_ProcessState;
  80.  
  81.  
  82. /*
  83.  * The following low-level file system types have to be exported because
  84.  * the type of Fs_Stream is already exported.  This could be fixed by
  85.  * only exporting an opaque Fs_StreamPtr type, or by changing the definition
  86.  * of Fs_Stream from a struct to a pointer to the struct.
  87.  */
  88.  
  89. /*
  90.  * All kinds of things are referenced from the object hash table.  The generic
  91.  * term for each structure is "handle".  The following structure defines a 
  92.  * common structure needed in the beginning of each handle.  Note, most of
  93.  * these fields are private to the FsHandle* routines that do generic
  94.  * operations on handles.  One exception is that the refCount on FSIO_STREAM
  95.  * handles is manipulated by the stream routines.  The handle must be
  96.  * locked when examining the refCount, and it should only be changed
  97.  * under the handle monitor lock by the FsHandle* routines.
  98.  */
  99.  
  100. typedef struct Fs_HandleHeader {
  101.     Fs_FileID        fileID;        /* Used as the hash key. */
  102.     int            flags;        /* Defined in fsHandle.c. */
  103.     Sync_Condition    unlocked;    /* Notified when handle is unlocked. */
  104.     int            refCount;    /* Used for garbage collection. */
  105.     char        *name;        /* Used for error messages */
  106.     List_Links        lruLinks;    /* For LRU list of handles */
  107. #ifndef CLEAN
  108.     Proc_ControlBlock    *lockProcPtr;    /* pcb of process that has the 
  109.                      * lock */
  110. #endif
  111. } Fs_HandleHeader;
  112.  
  113. #define LRU_LINKS_TO_HANDLE(listPtr) \
  114.     ( (Fs_HandleHeader *)((int)(listPtr) - sizeof(Fs_FileID) \
  115.         - 2 * sizeof(int) - sizeof(char *) - sizeof(Sync_Condition)) )
  116.  
  117.  
  118.  
  119. /*
  120.  * The following name-related information is referenced by each stream.
  121.  * This identifies the name of the file, which will be different than
  122.  * the file itself in the case of devices.  This is used to get to the
  123.  * name server during set/get attributes operations.  Also, this name
  124.  * fileID is used as the starting point for relative lookups.
  125.  */
  126.  
  127. typedef struct Fs_NameInfo {
  128.     Fs_FileID        fileID;        /* Identifies file and name server. */
  129.     Fs_FileID        rootID;        /* ID of file system root.  Passed
  130.                      * to name server to prevent ascending
  131.                      * past the root of a domain with ".."*/
  132.     int            domainType;    /* Name domain type */
  133.     struct Fsprefix    *prefixPtr;    /* Back pointer to prefix table entry.
  134.                      * This is kept for efficient handling
  135.                      * of lookup redirects. */
  136. } Fs_NameInfo;
  137.  
  138. /*
  139.  * Fs_Stream - A clients handle on an open file is defined by the Fs_Stream
  140.  *      structure.  A stream has a read-write offset index, state flags
  141.  *    that determine how the stream is being used (ie, for reading
  142.  *    or writing, etc.), name state used for get/set attributes,
  143.  *    and an I/O handle used for I/O operations.
  144.  *    There are many different types of I/O handles; they correspond
  145.  *    to local files, remote files, local devices, remote devices,
  146.  *    local pipes, remote pipes, locally cached named pipes,
  147.  *    remotely cached named pipes, control streams for pseudo devices,
  148.  *    psuedo streams, their corresponding server streams, etc. etc.
  149.  *    The different I/O handles types are defined in fsInt.h
  150.  *
  151.  *    This top level Fs_Stream structure is also given a handle type
  152.  *    and kept in the handle table because of process migration and
  153.  *    the shadow streams that file servers have to keep - on both
  154.  *    the client and the server there will be a Fs_Stream that
  155.  *    references an I/O handle.  The I/O handles will be different
  156.  *    types on the client (i.e. remote file) and the server (local file).
  157.  *    The Fs_Stream object will be the same, however, with the same
  158.  *    usage flags and internal ID.
  159.  *
  160.  */
  161.  
  162. typedef struct Fs_Stream {
  163.     Fs_HandleHeader    hdr;        /* Global stream identifier.  This
  164.                      * includes a reference count which
  165.                      * is incremented on fork/dup */
  166.     int            offset;        /* File access position */
  167.     int            flags;        /* Flags defined below */
  168.     Fs_HandleHeader    *ioHandlePtr;    /* Stream specific data used for I/O.
  169.                      * This really references a somewhat
  170.                      * larger object, see fsInt.h */
  171.     Fs_NameInfo         *nameInfoPtr;    /* Used to contact the name server */
  172.     List_Links        clientList;    /* Needed for recovery and sharing
  173.                      * detection */
  174. } Fs_Stream;
  175.  
  176. /*
  177.  * Flags in Fs_Stream that are only set/used by the kernel.
  178.  * (Flags passed in from callers of Fs_Open are defined in user/fs.h
  179.  *  The low order 12 bits of the flags word are reserved for those flags.)
  180.  * There are two groups of flags, the first is used mainly at lookup time
  181.  *    and the rest apply to I/O operations.
  182.  *
  183.  *    (These open related bit values are defined in user/fs.h)
  184.  *    FS_CREATE - Create if it doesn't exist.
  185.  *    FS_TRUNC  - Truncate to zero length on opening
  186.  *    FS_EXCULSIVE - With FS_CREATE causes open to fail if the file exists.
  187.  *    FS_MASTER - Open pseudo-device as the server process
  188.  *    FS_NAMED_PIPE_OPEN - Open a named pipe
  189.  *    FS_CLOSE_ON_EXEC - Cause stream to be closed when the opening
  190.  *        process executes a different program.
  191.  *
  192.  *    (These I/O related bit values are defined in user/fs.h)
  193.  *    FS_READ - Open for reading    (also FS_READABLE)
  194.  *    FS_WRITE - Open for writing    (also FS_WRITABLE)
  195.  *    FS_EXECUTE - Open for execution    (also FS_EXCEPTION)
  196.  *    FS_APPEND - Open for append mode
  197.  *    FS_NON_BLOCKING - Open a stream with non-blocking I/O operations. If
  198.  *        the operation would normally block, FS_WOULD_BLOCK is returned.
  199.  *
  200.  *    (These open-time bit values are defined below)
  201.  *      FS_FOLLOW - follow symbolic links during look up.
  202.  *    FS_PREFIX - Set when opening prefixes for export.
  203.  *    FS_SWAP - Set when opening swap files.  They are not cached on
  204.  *        remote clients and this flag is used to set caching state.
  205.  *    FS_OWNERSHIP - ownership permission.  The calling process has to
  206.  *        own the file in order for a lookup to succeed.  This is
  207.  *        used for setting attributes.
  208.  *    FS_DELETE - Open a file for deletion.  Write permission is needed
  209.  *        in the parent directory for this to succeed.
  210.  *    FS_LINK - This is used by FslclLookup to make hard links.  Instead
  211.  *        of creating a new file, FslclLookup makes another directory
  212.  *        reference (hard link) to an existing file.
  213.  *    FS_RENAME - This goes with FS_LINK if the link is being made in
  214.  *        preparation for a rename operation.  This allows the link,
  215.  *        which in this case is temporary, to be made to a directory.
  216.  *
  217.  *    (These I/O related bit values are defined below)
  218.  *      FS_USER - the file is a user file.  The buffer space is
  219.  *              in a user's address space.
  220.  *    FS_USER_IN - For I/O Control, the input buffer is in user space
  221.  *    FS_USER_OUT - For I/O Control, the output buffer is in user space
  222.  *    FS_CLIENT_CACHE_WRITE -    This write is coming from a client's cache.
  223.  *              This means the modify time should not be updated
  224.  *              since the client has the correct modify time.
  225.  *    FS_HEAP - This is a heap page for special treatment in the cache.
  226.  *    FS_SERVER_WRITE_THRU - Set on writes that are supposed to be written
  227.  *                   through to the server.
  228.  *    FS_LAST_DIRTY_BLOCK - Set on remote writes when this is the
  229.  *        last dirty block of the file to be written back.
  230.  *    FS_RMT_SHARED - Set on streams that are shared among clients on
  231.  *        separate machines.  For regular files this means that the
  232.  *        stream offset is being maintained on the server.
  233.  *    FS_NEW_STREAM - Migration related.  This tells the I/O server that
  234.  *        the destination of a migration is getting a stream for
  235.  *        the first time.   It needs to know this in order to do
  236.  *        I/O client book-keeping correctly.
  237.  *    FS_WRITE_TO_DISK - Write this block through to disk.
  238.  *    FS_MAP - File is being mapped into virtual memory.
  239.  *    FS_MIGRATED_FILE - Migration related.  This says a file has been
  240.  *        involved in a migration, so (for example) if the file
  241.  *        gets flushed to the server then the host that's flushing
  242.  *        it knows to attribute the flush to migration.  Used
  243.  *        for statistics.
  244.  *    FS_MIGRATING - Migration related.  This says a file is in the
  245.  *        process of migrating.  Also used for statistics.
  246.  *        MIGRATED_FILE stays set for any file that has ever been
  247.  *        migrated (it is reset if the file is not open anywhere), while
  248.  *        MIGRATING is set as a temporary flag during cache consistency
  249.  *        operations, for a single reference to the file.
  250.  */
  251. #define FS_KERNEL_FLAGS        0xfffff000
  252. #define FS_FOLLOW        0x00001000
  253. #define FS_PREFIX        0x00002000
  254. #define FS_SWAP            0x00004000
  255. #define FS_USER            0x00008000
  256. #define FS_USER_IN        FS_USER
  257. #define FS_OWNERSHIP        0x00010000
  258. #define FS_DELETE        0x00020000
  259. #define FS_LINK            0x00040000
  260. #define FS_RENAME        0x00080000
  261. #define FS_CLIENT_CACHE_WRITE    0x00100000
  262. #define    FS_DIR            0x00200000
  263. #define FS_HEAP            0x00400000
  264. #define FS_USER_OUT        0x00800000
  265. #define    FS_SERVER_WRITE_THRU    0x01000000
  266. #define    FS_LAST_DIRTY_BLOCK    0x02000000
  267. #define FS_RMT_SHARED        0x04000000
  268. #define FS_NEW_STREAM        0x08000000
  269. #define    FS_WRITE_TO_DISK    0x10000000
  270. #define    FS_MAP            0x20000000
  271. #define    FS_MIGRATED_FILE    0x40000000
  272. #define    FS_MIGRATING        0x80000000
  273.  
  274.  
  275. /*
  276.  * Basic I/O parameters.  Note that the stream is identified by context,
  277.  * either the pseudo-device connection or additional RPC parameters.
  278.  * This structure is initialized in Fs_Read/Write and passed down to
  279.  * the stream-specific I/O routines.  This record should be considered
  280.  * read-only to avoid conflicts with other layers.
  281.  * Fs_IOReply is used to return information about the transfer.
  282.  */
  283.  
  284. typedef struct Fs_IOParam {
  285.     Address    buffer;            /* Buffer for data */
  286.     int        length;            /* Byte amount to transfer */
  287.     int        offset;            /* Byte offset at which to transfer */
  288.     int        flags;            /* Operation specific flags */
  289.     Proc_PID    procID;            /* Process ID and Family ID of this */
  290.     Proc_PID    familyID;        /* process */
  291.     int        uid;            /* Effective user ID */
  292.     int        reserved;        /* Not used */
  293. } Fs_IOParam;
  294.  
  295. /*
  296.  * FsSetIOParam - macro to initialize Fs_IOParam record.
  297.  */
  298. #define FsSetIOParam(ioPtr, zbuffer, zlength, zoffset, zflags) \
  299.     { \
  300.     register Proc_ControlBlock *procPtr = Proc_GetEffectiveProc(); \
  301.     (ioPtr)->buffer = zbuffer; \
  302.     (ioPtr)->length = zlength; \
  303.     (ioPtr)->offset = zoffset; \
  304.     (ioPtr)->flags = zflags; \
  305.     (ioPtr)->procID = procPtr->processID; \
  306.     (ioPtr)->familyID = procPtr->familyID; \
  307.     (ioPtr)->uid = procPtr->userID; \
  308.     (ioPtr)->reserved = 0; \
  309.     }
  310.  
  311. /*
  312.  * Fs_IOReply is used to return info from stream-specific I/O routines
  313.  * back up to Fs_Read/Write.  The length has to be updated to reflect how
  314.  * much data was transferred.  The routines can also cause a signal to
  315.  * be generated by setting signal to non-zero.  The signal and code
  316.  * are initialized to zero by top-level routines, so these fields can
  317.  * be ignored if no signal is to be generated.  Finally, the flags field
  318.  * contains the three select bits that indicate the state of the object
  319.  * after the operation.
  320.  */
  321. typedef struct Fs_IOReply {
  322.     int        length;            /* Amount transferred */
  323.     int        flags;            /* Stream flags used, noted below. */
  324.     int        signal;            /* Signal to generate, or zero */
  325.     int        code;            /* Code to modify signal */
  326. } Fs_IOReply;
  327.  
  328. /*
  329.  * Flag bits for Fs_IOReply:
  330.  *    FS_READABLE        Object is currently readable
  331.  *    FS_WRITABLE        Object is currently writable
  332.  *    FS_EXCEPTION        Object has an outstanding exception
  333.  *
  334.  * These bits are defined above because they come from the stream flags.
  335.  */
  336.  
  337. /*
  338.  * Parameters for I/O Control.  There is also a returned Fs_IOReply
  339.  * that specifies the amount of valid data in the outBuffer,
  340.  * and a signal to return, if any.
  341.  */
  342.  
  343. typedef struct Fs_IOCParam {
  344.     int        command;    /* I/O Control to perform. */
  345.     Address    inBuffer;    /* Input buffer */
  346.     int        inBufSize;    /* Size of input params to iocontrol. */
  347.     Address    outBuffer;    /* Output buffer */
  348.     int        outBufSize;    /* Size of results from iocontrol. */
  349.     Fmt_Format    format;        /* Defines client's byte order/alignment
  350.                  * format. */
  351.     Proc_PID    procID;        /* ID of invoking process */
  352.     Proc_PID    familyID;    /* Family of invoking process */
  353.     int        uid;        /* Effective user ID */
  354.     int        flags;        /* FS_USER_IN and FS_USER_OUT indicate if
  355.                  * input and output buffers are in user space,
  356.                  * respectively */
  357. } Fs_IOCParam;
  358.  
  359. /*
  360.  * FS_MAX_LINKS    - the limit on the number of symbolic links that can be
  361.  *    expanded within a single domain.  This is also the limit on the
  362.  *    number of re-directs between domains that can occur during lookup.
  363.  */
  364. #define FS_MAX_LINKS    10
  365.  
  366. /*
  367.  * Values for  page type for Fs_PageRead.
  368.  */
  369. typedef enum {
  370.     FS_CODE_PAGE,
  371.     FS_HEAP_PAGE,
  372.     FS_SWAP_PAGE,
  373.     FS_SHARED_PAGE
  374. } Fs_PageType;
  375.  
  376.  
  377. /*
  378.  * Device drivers use Fs_NotifyReader and Fs_NotifyWriter to indicate
  379.  * that a device is ready.  They pass a Fs_NotifyToken as an argument
  380.  * that represents to the file system the object that is ready.
  381.  */
  382. typedef Address Fs_NotifyToken;
  383.  
  384. /*
  385.  * Flags returned from device driver open procedures.
  386.  *
  387.  * FS_DEV_DONT_LOCK    - Do not lock the device's handle during IO operations.
  388.  *              The default is to only allow one call to a device's
  389.  *              read or write procedures active at any time. Device's
  390.  *              that set this flag are responsible for doing their
  391.  *              own synchronization.
  392.  * FS_DEV_DONT_COPY    - Do not copy user resident IO buffers in and out of
  393.  *              the kernel for this device. The default is to 
  394.  *              malloc() a kernel resident buffer for device IO
  395.  *              operation.  Device's that set this flag are
  396.  *              responsible for doing IO operations directly to
  397.  *              user's address spaces.
  398.  */
  399.  
  400. #define    FS_DEV_DONT_LOCK    0x1
  401. #define    FS_DEV_DONT_COPY    0x2
  402.  
  403. /*
  404.  * TRUE once the file system has been initialized, so we
  405.  * know we can sync the disks safely.
  406.  */
  407. extern  Boolean fsutil_Initialized;    
  408.  
  409. /*
  410.  * These record the maximum transfer size supported by the RPC system.
  411.  */
  412. extern int fsMaxRpcDataSize;
  413. extern int fsMaxRpcParamSize;
  414.  
  415. /*
  416.  * Filesystem initialization calls.
  417.  */
  418. extern void Fs_Init _ARGS_((void));
  419. extern void Fs_InitData _ARGS_((void));
  420. extern void Fs_InitNameSpace _ARGS_((void));
  421. extern void Fs_Bin _ARGS_((void));
  422. extern void Fs_ProcInit _ARGS_((void));
  423. extern void Fs_InheritState _ARGS_((Proc_ControlBlock *parentProcPtr,
  424.                 Proc_ControlBlock *newProcPtr));
  425. extern void Fs_CloseState _ARGS_((Proc_ControlBlock *procPtr, int phase));
  426.  
  427.  
  428. /*
  429.  * Filesystem system calls.
  430.  */
  431. extern ReturnStatus Fs_AttachDiskStub _ARGS_((char *userDeviceName, 
  432.             char *userLocalName, int flags));
  433. extern ReturnStatus Fs_ChangeDirStub _ARGS_((char *pathName));
  434. extern ReturnStatus Fs_RemoveStub _ARGS_((char *pathName));
  435. extern ReturnStatus Fs_CommandStub _ARGS_((int command, int bufSize, 
  436.             Address buffer));
  437. extern ReturnStatus Fs_CreatePipeStub _ARGS_((int *inStreamIDPtr, 
  438.             int *outStreamIDPtr));
  439. extern ReturnStatus Fs_GetAttributesIDStub _ARGS_((int streamID, 
  440.             Fs_Attributes *attrPtr));
  441. extern ReturnStatus Fs_GetAttributesStub _ARGS_((char *pathName, 
  442.             int fileOrLink, Fs_Attributes *attrPtr));
  443. extern ReturnStatus Fs_GetNewIDStub _ARGS_((int streamID, int *newStreamIDPtr));
  444. extern ReturnStatus Fs_HardLinkStub _ARGS_((char *fileName, char *linkName));
  445. extern ReturnStatus Fs_IOControlStub _ARGS_((int streamID, int command, 
  446.             int inBufSize, Address inBuffer, int outBufSize, 
  447.             Address outBuffer));
  448. extern ReturnStatus Fs_MakeDeviceStub _ARGS_((char *pathName, 
  449.             Fs_Device *devicePtr, int permissions));
  450. extern ReturnStatus Fs_MakeDirStub _ARGS_((char *pathName, int permissions));
  451. extern ReturnStatus Fs_OpenStub _ARGS_((char *pathName, int usageFlags, 
  452.             int permissions, int *streamIDPtr));
  453. extern ReturnStatus Fs_ReadLinkStub _ARGS_((char *linkName, int bufSize, 
  454.             char *buffer, int *linkSizePtr));
  455. extern ReturnStatus Fs_ReadStub _ARGS_((int streamID, int amountRead, 
  456.             Address buffer, int *amountReadPtr));
  457. extern ReturnStatus Fs_ReadVectorStub _ARGS_((int streamID, int numVectors, 
  458.             Fs_IOVector userVectorArray[], int *amountReadPtr));
  459. extern ReturnStatus Fs_RemoveDirStub _ARGS_((char *pathName));
  460. extern ReturnStatus Fs_RemoveDirStub _ARGS_((char *pathName));
  461. extern ReturnStatus Fs_RenameStub _ARGS_((char *pathName, char *newName));
  462. extern ReturnStatus Fs_SelectStub _ARGS_((int numStreams, Time *userTimeoutPtr,
  463.             int *userReadMaskPtr, int *userWriteMaskPtr, 
  464.             int *userExceptMaskPtr, int *numReadyPtr));
  465. extern ReturnStatus Fs_SetAttributesIDStub _ARGS_((int streamID, 
  466.             Fs_Attributes *attrPtr));
  467. extern ReturnStatus Fs_SetAttributesStub _ARGS_((char *pathName, 
  468.             int fileOrLink, Fs_Attributes *attrPtr));
  469. extern ReturnStatus Fs_SetAttrIDStub _ARGS_((int streamID, 
  470.             Fs_Attributes *attrPtr, int flags));
  471. extern ReturnStatus Fs_SetAttrStub _ARGS_((char *pathName, int fileOrLink, 
  472.             Fs_Attributes *attrPtr, int flags));
  473. extern ReturnStatus Fs_SetDefPermStub _ARGS_((int permissions, int *oldPermPtr));
  474. extern ReturnStatus Fs_SymLinkStub _ARGS_((char *targetName, 
  475.             char *linkName, Boolean remoteFlag));
  476. extern ReturnStatus Fs_WriteStub _ARGS_((int streamID, int writeLength, 
  477.             Address buffer, int *writeLengthPtr));
  478. extern ReturnStatus Fs_WriteVectorStub _ARGS_((int streamID, int numVectors,
  479.             Fs_IOVector userVectorArray[], int *amountWrittenPtr));
  480. extern ReturnStatus Fs_FileWriteBackStub _ARGS_((int streamID, int firstByte, 
  481.             int lastByte, Boolean shouldBlock));
  482.  
  483. /*
  484.  * Filesystem system calls given accessible arguments.
  485.  */
  486. extern ReturnStatus Fs_UserClose _ARGS_((int streamID));
  487. extern ReturnStatus Fs_UserRead _ARGS_((int streamID, int amountRead,
  488.             Address buffer, int *amountReadPtr));
  489. extern ReturnStatus Fs_UserReadVector _ARGS_((int streamID, int numVectors, 
  490.             Fs_IOVector *vectorPtr, int *amountReadPtr));
  491. extern ReturnStatus Fs_UserWrite _ARGS_((int streamID, int writeLength, 
  492.             Address buffer, int *writeLengthPtr));
  493. extern ReturnStatus Fs_WriteVectorStub _ARGS_((int streamID, int numVectors, 
  494.             Fs_IOVector userVectorArray[], int *amountWrittenPtr));
  495. extern ReturnStatus Fs_UserWriteVector _ARGS_((int streamID, int numVectors, 
  496.             Fs_IOVector *vectorPtr, int *amountWrittenPtr));
  497.  
  498. /*
  499.  * Kernel equivalents of the filesystem system calls.
  500.  */
  501. extern ReturnStatus Fs_ChangeDir _ARGS_((char *pathName));
  502. extern ReturnStatus Fs_Close _ARGS_((register Fs_Stream *streamPtr));
  503. extern ReturnStatus Fs_Command _ARGS_((int command, int bufSize, 
  504.             Address buffer));
  505. extern ReturnStatus Fs_CheckAccess _ARGS_((char *pathName, int perm, 
  506.             Boolean useRealID));
  507. extern ReturnStatus Fs_GetAttributes _ARGS_((char *pathName, int fileOrLink,
  508.             Fs_Attributes *attrPtr));
  509. extern ReturnStatus Fs_GetNewID _ARGS_((int streamID, int *newStreamIDPtr));
  510. extern ReturnStatus Fs_HardLink _ARGS_((char *pathName, char *linkName));
  511. extern ReturnStatus Fs_IOControl _ARGS_((Fs_Stream *streamPtr,
  512.             Fs_IOCParam *ioctlPtr, Fs_IOReply *replyPtr));
  513. extern ReturnStatus Fs_MakeDevice _ARGS_((char *name, Fs_Device *devicePtr,
  514.             int permissions));
  515. extern ReturnStatus Fs_MakeDir _ARGS_((char *name, int permissions));
  516. extern ReturnStatus Fs_Open _ARGS_((char *name, register int useFlags, 
  517.             int type, int permissions, Fs_Stream **streamPtrPtr));
  518. extern ReturnStatus Fs_Read _ARGS_((Fs_Stream *streamPtr, Address buffer, 
  519.             int offset, int *lenPtr));
  520. extern ReturnStatus Fs_Remove _ARGS_((char *name));
  521. extern ReturnStatus Fs_RemoveDir _ARGS_((char *name));
  522. extern ReturnStatus Fs_Rename _ARGS_((char *pathName, char *newName));
  523. extern ReturnStatus Fs_SetAttributes _ARGS_((char *pathName, int fileOrLink, 
  524.             Fs_Attributes *attrPtr, int flags));
  525. extern ReturnStatus Fs_SymLink _ARGS_((char *targetName, char *linkName, 
  526.             Boolean remoteFlag));
  527. extern ReturnStatus Fs_Trunc _ARGS_((char *pathName, int length));
  528. extern ReturnStatus Fs_TruncStream _ARGS_((Fs_Stream *streamPtr, int length));
  529. extern ReturnStatus Fs_Write _ARGS_((Fs_Stream *streamPtr, Address buffer, 
  530.             int offset, int *lenPtr));
  531.  
  532. /*
  533.  * Filesystem utility routines.
  534.  */
  535. extern void Fs_CheckSetID _ARGS_((Fs_Stream *streamPtr, int *uidPtr, 
  536.                 int *gidPtr));
  537. extern void Fs_CloseOnExec _ARGS_((Proc_ControlBlock *procPtr));
  538.  
  539.  
  540. /*
  541.  * Routines to support process migration: encapsulate and deencapsulate
  542.  * streams and other file state, and clear file state after migration.
  543.  */
  544. extern ReturnStatus Fs_InitiateMigration _ARGS_((Proc_ControlBlock *procPtr, 
  545.             int hostID, Proc_EncapInfo *infoPtr));
  546. extern int Fs_GetEncapSize _ARGS_((void));
  547. extern ReturnStatus Fs_EncapFileState _ARGS_((Proc_ControlBlock *procPtr, 
  548.             int hostID, Proc_EncapInfo *infoPtr, 
  549.             Address ptr));
  550. extern ReturnStatus Fs_DeencapFileState _ARGS_((Proc_ControlBlock *procPtr, 
  551.              Proc_EncapInfo *infoPtr, Address buffer));
  552.  
  553. /*
  554.  * Routines for virtual memory.
  555.  */
  556. extern ReturnStatus Fs_PageRead _ARGS_((Fs_Stream *streamPtr, Address pageAddr,
  557.             int offset, int numBytes, Fs_PageType pageType));
  558. extern ReturnStatus Fs_PageWrite _ARGS_((Fs_Stream *streamPtr,Address pageAddr,
  559.             int offset, int numBytes, Boolean toDisk));
  560. extern ReturnStatus Fs_PageCopy _ARGS_((Fs_Stream *srcStreamPtr, 
  561.             Fs_Stream *destStreamPtr, int offset, int numBytes));
  562. extern ReturnStatus Fs_FileBeingMapped _ARGS_((Fs_Stream *streamPtr, 
  563.             int isMapped));
  564.  
  565. /*
  566.  * Routines that map to/from user-level streamIDs.
  567.  */
  568. extern ReturnStatus Fs_GetStreamID _ARGS_((Fs_Stream *streamPtr, 
  569.             int *streamIDPtr));
  570. extern void Fs_ClearStreamID _ARGS_((int streamID, Proc_ControlBlock *procPtr));
  571. extern ReturnStatus Fs_GetStreamPtr _ARGS_((Proc_ControlBlock *procPtr, 
  572.             int streamID, Fs_Stream **streamPtrPtr));
  573.  
  574. extern ReturnStatus Fs_GetAttrStream _ARGS_((Fs_Stream *streamPtr, 
  575.             Fs_Attributes *attrPtr));
  576. extern ReturnStatus Fs_SetAttrStream _ARGS_((Fs_Stream *streamPtr,
  577.             Fs_Attributes *attrPtr, Fs_UserIDs *idPtr, int flags));
  578. extern void Fs_CheckSetID _ARGS_((Fs_Stream *streamPtr, int *uidPtr, 
  579.             int *gidPtr));
  580.  
  581. extern ClientData Fs_GetFileHandle _ARGS_((Fs_Stream *streamPtr));
  582. extern struct Vm_Segment **Fs_GetSegPtr _ARGS_((ClientData fileHandle));
  583.  
  584. #endif /* _FS */
  585.